The Design of GP 2

This papers defines the syntax and semantics of GP 2, a revised version of the graph programming language GP. New concepts are illustrated and explained with example programs. Changes to the first version of GP include an improved type system for labels, a built-in marking mechanism for nodes and edges, a more powerful edge predicate for conditional rule schemata, and functions returning the indegree and outdegree of matched nodes. Moreover, the semantics of the branching and loop statement have been simplified to allow their efficient implementation.Comment: In Proceedings WRS 2011, arXiv:1204.531

Checking Graph-Transformation Systems for Confluence

In general, it is undecidable whether a terminating graph-transformation system is confluent or not. We introduce the class of coverable hypergraph-transformation systems and show that confluence is decidable for coverable systems that are terminating. Intuitively, a system is coverable if its typing allows to extend each critical pair with a non-deletable context that uniquely identifies the persistent nodes of the pair. The class of coverable systems includes all hypergraph-transformation systems in which hyperedges can connect arbitrary sequences of nodes, and all graph-transformation systems with a sufficient number of unused edge labels

Towards Critical Pair Analysis for the Graph Programming Language GP 2

Part 4: Regular PapersInternational audienceWe present the foundations of critical pair analysis for the graph programming language GP 2. Our goal is to develop a static checker that can prove or refute confluence (functional behaviour) for a large class of graph programs. In this paper, we introduce symbolic critical pairs of GP 2 rule schemata, which are labelled with expressions, and establish the completeness and finiteness of the set of symbolic critical pairs over a finite set of rule schemata. We give a procedure for their construction

A Reference Interpreter for the Graph Programming Language GP 2

GP 2 is an experimental programming language for computing by graph transformation. An initial interpreter for GP 2, written in the functional language Haskell, provides a concise and simply structured reference implementation. Despite its simplicity, the performance of the interpreter is sufficient for the comparative investigation of a range of test programs. It also provides a platform for the development of more sophisticated implementations.Comment: In Proceedings GaM 2015, arXiv:1504.0244

The GP Programming System

We describe the programming system for the graph-transformation language GP, focusing on the implementation of its compiler and abstract machine. We also compare the system's performance with other graph-transformation systems. The GP language is based on conditional rule schemata and comes with a simple formal semantics which maps input graphs to sets of output graphs. The implementation faithfully matches the semantics by using backtracking and allowing to compute all possible results for a given input

A Unification Algorithm for GP 2

The graph programming language GP 2 allows to apply sets of ruleschemata (or “attributed” rules) non-deterministically. To analyse conflicts of pro-grams statically, graphs labelled with expressisons are overlayed to construct criticalpairs of rule applications. Each overlay induces a system of equations whose solu-tions represent different conflicts. We present a rule-based unification algorithm forGP expressions that is terminating, sound and complete. For every input equation,the algorithm generates a finite set of substitutions. Soundness means that each ofthese substitutions solves the input equation. Since GP labels are lists constructed byconcatenation, unification modulo associativity and unit law is required. This prob-lem, which is also known as word unification, is infinitary in general but becomesfinitary due to GP’s rule schema syntax and the assumption that rule schemata areleft-linear. Our unification algorithm is complete in that every solution of an inputequation is an instance of some substitution in the generated set

Rooted Graph Programs

We present an approach for programming with graph transformation rules in which programs can be as efficient as programs in imperative languages. The basic idea is to equip rules and host graphs with distinguished nodes, so-called roots, and to match roots in rules with roots in host graphs. This enables graph transformation rules to be matched in constant time, provided that host graphs have a bounded node degree (which in practice is often the case). Hence, for example, programs with a linear bound on the number of rule applications run in truly linear time. We demonstrate the feasibility of this approach with a case study in graph colouring